package com.youdoneed.friends.comments;

import com.querydsl.core.types.dsl.NumberExpression;
import com.querydsl.sql.SQLQuery;
import com.querydsl.sql.SQLQueryFactory;
import com.querydsl.sql.dml.SQLUpdateClause;
import com.youdoneed.base.application.AppException;
import com.youdoneed.base.common.GlobalIdWorker;
import com.youdoneed.base.pagination.Page;
import com.youdoneed.friends.application.QueryHelper;
import com.youdoneed.friends.model.CommentsTemplate;
import com.youdoneed.friends.query.QCommentsTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.Date;

@Service
@Transactional
public class CommentsTemplateService {

    private final Logger logger = LoggerFactory.getLogger(CommentsTemplateService.class);

    @Autowired
    private SQLQueryFactory queryFactory;
    private QCommentsTemplate qCommentsTemplate = QCommentsTemplate.CommentsTemplate;

    /**
     * 获取留言模板。
     */
    public CommentsTemplate getCommentsTemplate(String templateId) {
        if (!StringUtils.hasText(templateId)) {
            throw new AppException("留言模板ID不能为空！");
        }
        return queryFactory.selectFrom(qCommentsTemplate)
                .where(qCommentsTemplate.templateId.eq(templateId))
                .fetchOne();
    }

    /**
     * 保存留言模板
     */
    public long save(CommentsTemplate record) {
        if (!StringUtils.hasText(record.getContent())) {
            throw new AppException("留言模板内容不能为空！");
        }
        record.setTemplateId(GlobalIdWorker.nextString());
        record.setCreateTime(new Date());
        Integer maxSort = queryFactory.select(qCommentsTemplate.sort.max())
                .from(qCommentsTemplate)
                .fetchOne();
        if (maxSort == null) {
            record.setSort(1);
        } else {
            record.setSort(maxSort + 1);
        }
        return queryFactory.insert(qCommentsTemplate)
                .populate(record)
                .execute();
    }

    /**
     * 查找留言模板
     */
    public Page<CommentsTemplate> findTemplate(Paging paging, String userId) {
        SQLQuery<CommentsTemplate> query = queryFactory.selectFrom(qCommentsTemplate)
                // 随机取几条
                .orderBy(NumberExpression.random().asc());
        if (StringUtils.hasText(userId)) {
            query.where(qCommentsTemplate.userId.eq(userId));
        }
        return QueryHelper.queryPage(paging, query);
    }

    /**
     * 查询留言模板
     */
    public Page<CommentsTemplate> findListByContent(Paging paging, String content) {
        SQLQuery<CommentsTemplate> query = queryFactory.selectFrom(qCommentsTemplate)
                // 后台只显示系统模板
                .where(qCommentsTemplate.userId.isNull())
                .orderBy(qCommentsTemplate.sort.asc());
        if (StringUtils.hasText(content)) {
            query.where(qCommentsTemplate.content.contains(content));
        }
        return QueryHelper.queryPage(paging, query);
    }

    /**
     * 更新留言模板
     */
    public long update(String templateId, String content) {
        if (!StringUtils.hasText(templateId)) {
            throw new AppException("留言模板ID不能为空！");
        }
        if (!StringUtils.hasText(content)) {
            throw new AppException("留言模板内容不能为空！");
        }
        return queryFactory.update(qCommentsTemplate)
                .set(qCommentsTemplate.content, content)
                .where(qCommentsTemplate.templateId.eq(templateId))
                .execute();
    }

    /**
     * 删除留言模板
     */
    public long delete(String templateId) {
        if (!StringUtils.hasText(templateId)) {
            throw new AppException("留言模板ID不能为空！");
        }
        return queryFactory.delete(qCommentsTemplate)
                .where(qCommentsTemplate.templateId.eq(templateId))
                .execute();
    }

    public long sortMoveUp(String templateId) {
        if (!StringUtils.hasText(templateId)) {
            throw new AppException("职业ID为空。");
        }
        CommentsTemplate template = getCommentsTemplate(templateId);
        // 取前一条
        CommentsTemplate preTemplate = queryFactory.selectFrom(qCommentsTemplate)
                .where(qCommentsTemplate.sort.lt(template.getSort()))
                .orderBy(qCommentsTemplate.sort.desc())
                .fetchFirst();
        if (preTemplate == null) {
            throw new AppException("已经到顶了。");
        }
        return swapSort(preTemplate, template);
    }

    public long sortMoveDown(String templateId) {
        if (!StringUtils.hasText(templateId)) {
            throw new AppException("职业ID为空。");
        }
        CommentsTemplate template = getCommentsTemplate(templateId);
        // 取后一条
        CommentsTemplate nextTemplate = queryFactory.selectFrom(qCommentsTemplate)
                .where(qCommentsTemplate.sort.gt(template.getSort()))
                .orderBy(qCommentsTemplate.sort.asc())
                .fetchFirst();
        if (nextTemplate == null) {
            throw new AppException("已经到底了。");
        }
        return swapSort(nextTemplate, template);
    }

    /**
     * 交换顺序。
     */
    public long swapSort(CommentsTemplate templateIdA, CommentsTemplate templateIdB) {
        SQLUpdateClause update = queryFactory.update(qCommentsTemplate);
        update.set(qCommentsTemplate.sort, templateIdA.getSort())
                .where(qCommentsTemplate.templateId.eq(templateIdB.getTemplateId()))
                .addBatch();
        update.set(qCommentsTemplate.sort, templateIdB.getSort())
                .where(qCommentsTemplate.templateId.eq(templateIdA.getTemplateId()))
                .addBatch();
        return update.execute();
    }

}
